home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 9 / Night Owl CD-ROM (NOPV9) (Night Owl Publisher) (1993).ISO / 001a / seyon213.tz / seyon213 / seyon / SeActions.c < prev    next >
C/C++ Source or Header  |  1993-04-10  |  12KB  |  479 lines
  1.  
  2. /*
  3.  * This file is part of the Seyon, Copyright (c) 1992-1993 by Muhammad M.
  4.  * Saggaf. All rights reserved.
  5.  *
  6.  * See the file COPYING (1-COPYING) or the manual page seyon(1) for a full
  7.  * statement of rights and permissions for this program.
  8.  */
  9.  
  10. #include <stdlib.h>
  11. #include <unistd.h>
  12. #include <string.h>
  13. #include <math.h>
  14. #include <X11/Intrinsic.h>
  15. #include <X11/StringDefs.h>
  16. #include <X11/Xaw/Command.h>
  17.  
  18. /* SeDecl.h includes stdio.h */
  19. #include "SeDecl.h"
  20.  
  21. #define CheckSet() {if (widget != curCommandWidget) return;}
  22. #define CheckNumParam(num) {if (*numParam != num) \
  23.   SimpleError("Wrong Number of Parameters");}
  24.  
  25. extern Widget   dialWidget;
  26.  
  27. Widget          curCommandWidget = (Widget)NULL;
  28.  
  29. void
  30. CommandSetAction(widget, event, param, numParam)
  31.      Widget          widget;
  32.      XEvent*         event;
  33.      String*         param;
  34.      Cardinal*       numParam;
  35. {
  36.   curCommandWidget = widget;
  37. }
  38.  
  39. void
  40. CommandUnsetAction(widget, event, param, numParam)
  41.      Widget          widget;
  42.      XEvent*         event;
  43.      String*         param;
  44.      Cardinal*       numParam;
  45. {
  46.   curCommandWidget = (Widget)NULL;
  47. }
  48.  
  49. void
  50. CallCallbacksAction(widget)
  51.      Widget          widget;
  52. {
  53.   XtCallCallbacks(widget, XtNdestroyCallback, NULL);
  54. }
  55.  
  56. void
  57. BeepAction(widget, event, param, numParam)
  58.      Widget          widget;
  59.      XEvent*         event;
  60.      String*         param;
  61.      Cardinal*       numParam;
  62. {
  63.   CheckNumParam(0);
  64.   Beep();
  65. }
  66.  
  67. void
  68. CloseWindowAction(widget, event, param, numParam)
  69.      Widget          widget;
  70.      XEvent*         event;
  71.      String*         param;
  72.      Cardinal*       numParam;
  73. {
  74.   int             DismissDirectory();
  75.   Widget          dirWidget;
  76.   int             i;
  77.  
  78.   for (i = 0; i < *numParam; i++) {
  79.     if (strcmp(param[i], "Dial") == 0)
  80.       {if ((dirWidget = XtNameToWidget(dialWidget, "directory")))
  81.          DismissDirectory(dirWidget);}
  82.     
  83.     else SimpleErrorF("Invalid Parameter `%s'", param[i], "", "");
  84.   } /* for... */
  85. }
  86.  
  87. void
  88. DialEntriesAction(widget, event, param, numParam)
  89.      Widget          widget;
  90.      XEvent*         event;
  91.      String*         param;
  92.      Cardinal*       numParam;
  93. {
  94.   ErrorIfBusy();
  95.   CheckNumParam(1);
  96.  
  97.   if (strcmp(*param, "Default")) TopDial(dialWidget, (XtPointer)*param);
  98.   else TopDial(dialWidget, (XtPointer)qres.defaultPhoneEntries);
  99. }
  100.  
  101. void
  102. DivertFileAction(widget, event, param, numParam)
  103.      Widget          widget;
  104.      XEvent*         event;
  105.      String*         param;
  106.      Cardinal*       numParam;
  107. {
  108.   void            DivertFile(),
  109.                   ExecDivertFile();
  110.          
  111.   ErrorIfBusy();
  112.   if (*numParam > 1)
  113.     SimpleError("Wrong Number of Parameters");
  114.  
  115.   if (*numParam == 0) DivertFile(widget);
  116.   else ExecDivertFile(widget, *param);
  117. }
  118.  
  119. void
  120. DoNothingAction(widget, event, param, numParam)
  121.      Widget          widget;
  122.      XEvent*         event;
  123.      String*         param;
  124.      Cardinal*       numParam;
  125. {
  126.   CheckNumParam(0);
  127. }
  128.  
  129. void
  130. EchoAction(widget, event, param, numParam)
  131.      Widget          widget;
  132.      XEvent*         event;
  133.      String*         param;
  134.      Cardinal*       numParam;
  135. {
  136.   if (*numParam == 0) show("");
  137.   CheckNumParam(1);
  138.   show(*param);
  139. }
  140.  
  141. void
  142. FileTransferAction(widget, event, param, numParam)
  143.      Widget          widget;
  144.      XEvent*         event;
  145.      String*         param;
  146.      Cardinal*       numParam;
  147. {
  148.   void            TopTransfer();
  149.   static String   pParam[2];
  150.   int             i;
  151.  
  152.   ErrorIfBusy();
  153.   if (*numParam < 1 || *numParam > 2)
  154.     SimpleError("Wrong Number of Parameters");
  155.  
  156.   for (i = 0; i < *numParam;) 
  157.     {pParam[i] = param[i]; pParam[++i] = NULL;}
  158.  
  159.   TopTransfer(widget, (XtPointer)pParam);
  160. }
  161.  
  162. void
  163. IconifyWindowAction(widget, event, param, numParam)
  164.      Widget          widget;
  165.      XEvent*         event;
  166.      String*         param;
  167.      Cardinal*       numParam;
  168. {
  169.   int             IconifyShell();
  170.   Widget          dirWidget;
  171.   static String   termWindowId = NULL;
  172.   int             i;
  173.  
  174.   for (i = 0; i < *numParam; i++) {
  175.     if (strcmp(param[i], "Main") == 0) IconifyShell(widget);
  176.  
  177.     else if (strcmp(param[i], "Dial") == 0)
  178.       {if ((dirWidget = XtNameToWidget(dialWidget, "directory")))
  179.          IconifyShell(dirWidget);}
  180.  
  181.     else if (strcmp(param[i], "Term") == 0) {
  182.       if (termWindowId == NULL) termWindowId = (String)getenv("WINDOWID");
  183.       if (termWindowId) 
  184.         XIconifyWindow(XtDisplay(widget), (Window)atol(termWindowId),
  185.                        XScreenNumberOfScreen(XtScreen(widget)));
  186.       else {
  187.         SeError("Could not get terminal window ID");
  188.         SeNotice("Maybe you're not using xterm?");
  189.         SimpleError("WINDOWID not Found");
  190.       }
  191.     } /* if strcmp Term... */
  192.  
  193.     else SimpleErrorF("Invalid Parameter `%s'", param[i], "", "");
  194.   } /* for... */
  195. }
  196.  
  197. void
  198. HangupAction(widget, event, param, numParam)
  199.      Widget          widget;
  200.      XEvent*         event;
  201.      String*         param;
  202.      Cardinal*       numParam;
  203. {
  204.   void            ExecHangup();
  205.  
  206.   CheckSet();
  207.   ErrorIfBusy();
  208.   CheckNumParam(0);
  209.   ExecHangup();
  210. }
  211.  
  212. void
  213. ManualDialAction(widget, event, param, numParam)
  214.      Widget          widget;
  215.      XEvent*         event;
  216.      String*         param;
  217.      Cardinal*       numParam;
  218. {
  219.   void            ManualDial(),
  220.                   ExecManualDial();
  221.  
  222.   ErrorIfBusy();
  223.   if (*numParam > 1)
  224.     SimpleError("Wrong Number of Parameters");
  225.  
  226.   if (*numParam == 0) ManualDial(widget);
  227.   else ExecManualDial(widget, *param);
  228. }
  229.  
  230. void
  231. MessageAction(widget, event, param, numParam)
  232.      Widget          widget;
  233.      XEvent*         event;
  234.      String*         param;
  235.      Cardinal*       numParam;
  236. {
  237.   if (*numParam == 0) SeyonMessage("");
  238.   CheckNumParam(1);
  239.   SeyonMessage(*param);
  240. }
  241.  
  242. void
  243. OpenWindowAction(widget, event, param, numParam)
  244.      Widget          widget;
  245.      XEvent*         event;
  246.      String*         param;
  247.      Cardinal*       numParam;
  248. {
  249.   int             IconifyShell();
  250.   Widget          dirWidget;
  251.   static String   termWindowId = NULL;
  252.   int             i;
  253.  
  254.   for (i = 0; i < *numParam; i++) {
  255.     if (strcmp(param[i], "Main") == 0) XtMapWidget(GetShell(widget));
  256.  
  257.     else if (strcmp(param[i], "Dial") == 0)
  258.       if ((dirWidget = XtNameToWidget(dialWidget, "directory")))
  259.         {XtPopup(dirWidget, XtGrabNone); XtMapWidget(dirWidget);}
  260.       else TopDial(dialWidget, NULL);
  261.  
  262.     else if (strcmp(param[i], "Term") == 0) {
  263.       if (termWindowId == NULL) termWindowId = (String)getenv("WINDOWID");
  264.       if (termWindowId) 
  265.         XMapRaised(XtDisplay(widget), (Window)atol(termWindowId));
  266.       else {
  267.         SeError("Could not get terminal window ID");
  268.         SeNotice("Maybe you're not using xterm?");
  269.         SimpleError("WINDOWID not Found");
  270.       }
  271.     } /* if strcmp Term... */
  272.  
  273.     else SimpleErrorF("Invalid Parameter `%s'", param[i], "", "");
  274.   } /* for... */
  275. }
  276.  
  277. void
  278. QuitAction(widget, event, param, numParam)
  279.      Widget          widget;
  280.      XEvent*         event;
  281.      String*         param;
  282.      Cardinal*       numParam;
  283. {
  284.   ErrorIfBusy();
  285.   CheckNumParam(0);
  286.   ExecExit();
  287. }
  288.  
  289. void
  290. RunScriptAction(widget, event, param, numParam)
  291.      Widget          widget;
  292.      XEvent*         event;
  293.      String*         param;
  294.      Cardinal*       numParam;
  295. {
  296.   void            DialogRunScript(),
  297.                   RunScript();
  298.            
  299.   ErrorIfBusy();
  300.   if (*numParam == 0) DialogRunScript(widget);
  301.   CheckNumParam(1);
  302.   RunScript(widget, *param);
  303. }
  304.  
  305. void
  306. SetAction(widget, event, param, numParam)
  307.      Widget          widget;
  308.      XEvent*         event;
  309.      String*         param;
  310.      Cardinal*       numParam;
  311. {
  312.   void            s_set();
  313.  
  314.   ErrorIfBusy();
  315.   CheckNumParam(2);
  316.   sprintf((lptr = line), "%s %s", param[0], param[1]);
  317.   eof_flag = 0;
  318.   s_set();
  319. }
  320.  
  321. void
  322. ShellCommandAction(widget, event, param, numParam)
  323.      Widget          widget;
  324.      XEvent*         event;
  325.      String*         param;
  326.      Cardinal*       numParam;
  327. {
  328.   ErrorIfBusy();
  329.   CheckNumParam(1);
  330.   ShellCommand(*param);
  331. }
  332.  
  333. void
  334. SleepAction(widget, event, param, numParam)
  335.      Widget          widget;
  336.      XEvent*         event;
  337.      String*         param;
  338.      Cardinal*       numParam;
  339. {
  340.   CheckNumParam(1);
  341.   sleep(atoi(*param));
  342. }
  343.  
  344. void
  345. TransmitAction(widget, event, param, numParam)
  346.      Widget          widget;
  347.      XEvent*         event;
  348.      String*         param;
  349.      Cardinal*       numParam;
  350. {
  351.   ErrorIfBusy();
  352.   CheckNumParam(1);
  353.   MdmPutString(*param);
  354. }
  355.  
  356. /*---------------------------------------------------------------------------+
  357. | DispatchActions - parses an action stack and dispatches its actions.
  358. +---------------------------------------------------------------------------*/
  359.  
  360. void
  361. DispatchActions(intData, stringData, widget)
  362.      int    intData;
  363.      String stringData;
  364.      Widget widget;
  365. {
  366.   int                 SeAppMSleep();
  367.   void                ParseThis();
  368.  
  369.   static Boolean      actionRunning = False,
  370.                       prevActionAsync = False;
  371.   static Widget       actionWidget;
  372.   static String       actionStack;
  373.  
  374.   void                (*actionProc)();
  375.   static char         actionName[SM_BUF],
  376.                       args[SM_BUF][SM_BUF];
  377.   static String       argsArray[SM_BUF];
  378.   static Cardinal     numArgs;
  379.   int                 i;
  380.  
  381.   struct _actionTable {
  382.     String        actionKeyWord;
  383.     void          (*actionProc)();
  384.     Boolean       async;
  385.   };
  386.  
  387.   static struct _actionTable actionTable[] = {
  388.     {"Beep", BeepAction, False},
  389.     {"CloseWindow", CloseWindowAction, False},
  390.     {"DialEntries", DialEntriesAction, True},
  391.     {"DivertFile", DivertFileAction, True},
  392.     {"DoNothing", DoNothingAction, False},
  393.     {"Echo", EchoAction, False},
  394.     {"FileTransfer", FileTransferAction, True},
  395.     {"IconifyWindow", IconifyWindowAction, False},
  396.     {"Hangup", HangupAction, False},
  397.     {"ManualDial", ManualDialAction, True},
  398.     {"Message", MessageAction, False},
  399.     {"OpenWindow", OpenWindowAction, False},
  400.     {"Quit", QuitAction, False},
  401.     {"RunScript", RunScriptAction, True},
  402.     {"Set", SetAction, False},
  403.     {"ShellCommand", ShellCommandAction, True},
  404.     {"Sleep", SleepAction, False},
  405.     {"Transmit", TransmitAction, False},
  406.     {NULL, NULL, False},
  407.   };
  408.  
  409.   switch (intData) {
  410.  
  411.   case ACTION_NEW_ACTION:
  412.     strcpy(actionName, stringData);
  413.     numArgs = 0;
  414.     return;
  415.  
  416.   case ACTION_NEW_ARG:
  417.     strcpy((argsArray[numArgs] = args[numArgs]), stringData);
  418.     numArgs++;
  419.     return;
  420.  
  421.   case ACTION_ARGS_END:
  422.     if (prevActionAsync) 
  423.       while(inhibit_child) 
  424.         XtAppProcessEvent(XtWidgetToApplicationContext(actionWidget), XtIMAll);
  425.  
  426.     for (i = 0; (actionProc = actionTable[i].actionProc) && 
  427.          strcmp(actionName, actionTable[i].actionKeyWord); i++);
  428.  
  429.     if (actionProc == NULL)
  430.       {SeError(FmtString("Invalid action: ``%s''", actionName, "", ""));
  431.        SimpleError("Invalid Action Specified");}
  432.  
  433.     (*actionProc)(actionWidget, NULL, argsArray, &numArgs);
  434.     prevActionAsync = actionTable[i].async;
  435.     return;
  436.  
  437.   case ACTION_PARSE_ERROR:
  438.     SeError(FmtString("%s in ``%s''", stringData, actionStack, ""));
  439.     return;
  440.  
  441.   case ACTION_DISPATCH:
  442.     if (actionRunning)
  443.       SimpleError("Action Still Running");
  444.     if (stringData == NULL || stringData[0] == '\0')
  445.       SimpleError("No Action Attached");
  446.  
  447.     actionWidget = widget;
  448.     actionStack = XtNewString(stringData);
  449.  
  450.     actionRunning = True;
  451.     prevActionAsync = False;
  452.     ParseThis(actionStack, DispatchActions);
  453.  
  454.     actionRunning = False;
  455.     XtFree(actionStack);
  456.     return;
  457.   }
  458. }
  459.  
  460. /*---------------------------------------------------------------------------+
  461. | DispatchActionsCallback - callback for dispatching SeQuickKey actions.
  462. +---------------------------------------------------------------------------*/
  463.  
  464. void
  465. DispatchActionsCallback(widget, clientData)
  466.      XtPointer widget;
  467.      XtPointer clientData;
  468. {
  469.   void                GetQuickKeyResources();
  470.  
  471.   String              widgetName;
  472.   struct _quickKeyRes quickKeyRes;
  473.  
  474.   GetQuickKeyResources((widgetName = XtName(widget)), &quickKeyRes);  
  475.   DispatchActions(ACTION_DISPATCH, quickKeyRes.action, widget);
  476. }
  477.  
  478.  
  479.